﻿namespace Smart.Utils.UI.BarcodeLib
{
    using System;
    using System.CodeDom.Compiler;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Data;
    using System.Diagnostics;
    using System.IO;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.Serialization;
    using System.Xml;
    using System.Xml.Schema;
    using System.Xml.Serialization;

    [Serializable, HelpKeyword("vs.data.DataSet"), XmlRoot("BarcodeXML"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), DesignerCategory("code"), ToolboxItem(true), XmlSchemaProvider("GetTypedDataSetSchema")]
    public class BarcodeXML : DataSet
    {
        private System.Data.SchemaSerializationMode _schemaSerializationMode;
        private BarcodeDataTable tableBarcode;

        [DebuggerNonUserCode]
        public BarcodeXML()
        {
            this._schemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
            base.BeginInit();
            this.InitClass();
            CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
            base.Tables.CollectionChanged += handler;
            base.Relations.CollectionChanged += handler;
            base.EndInit();
        }

        [DebuggerNonUserCode]
        protected BarcodeXML(SerializationInfo info, StreamingContext context) : base(info, context, false)
        {
            this._schemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
            if (base.IsBinarySerialized(info, context))
            {
                this.InitVars(false);
                CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
                this.Tables.CollectionChanged += handler;
                this.Relations.CollectionChanged += handler;
            }
            else
            {
                string s = (string) info.GetValue("XmlSchema", typeof(string));
                if (base.DetermineSchemaSerializationMode(info, context) == System.Data.SchemaSerializationMode.IncludeSchema)
                {
                    DataSet dataSet = new DataSet();
                    dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                    if (dataSet.Tables["Barcode"] != null)
                    {
                        base.Tables.Add(new BarcodeDataTable(dataSet.Tables["Barcode"]));
                    }
                    base.DataSetName = dataSet.DataSetName;
                    base.Prefix = dataSet.Prefix;
                    base.Namespace = dataSet.Namespace;
                    base.Locale = dataSet.Locale;
                    base.CaseSensitive = dataSet.CaseSensitive;
                    base.EnforceConstraints = dataSet.EnforceConstraints;
                    base.Merge(dataSet, false, MissingSchemaAction.Add);
                    this.InitVars();
                }
                else
                {
                    base.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                }
                base.GetSerializationData(info, context);
                CollectionChangeEventHandler handler2 = new CollectionChangeEventHandler(this.SchemaChanged);
                base.Tables.CollectionChanged += handler2;
                this.Relations.CollectionChanged += handler2;
            }
        }

        [DebuggerNonUserCode]
        public override DataSet Clone()
        {
            BarcodeXML exml = (BarcodeXML) base.Clone();
            exml.InitVars();
            exml.SchemaSerializationMode = this.SchemaSerializationMode;
            return exml;
        }

        [DebuggerNonUserCode]
        protected override XmlSchema GetSchemaSerializable()
        {
            MemoryStream w = new MemoryStream();
            base.WriteXmlSchema(new XmlTextWriter(w, null));
            w.Position = 0L;
            return XmlSchema.Read(new XmlTextReader(w), null);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
        {
            BarcodeXML exml = new BarcodeXML();
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = exml.Namespace;
            sequence.Items.Add(item);
            type.Particle = sequence;
            XmlSchema schemaSerializable = exml.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            base.DataSetName = "BarcodeXML";
            base.Prefix = "";
            base.Namespace = "http://tempuri.org/BarcodeXML.xsd";
            base.EnforceConstraints = true;
            this.SchemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;
            this.tableBarcode = new BarcodeDataTable();
            base.Tables.Add(this.tableBarcode);
        }

        [DebuggerNonUserCode]
        protected override void InitializeDerivedDataSet()
        {
            base.BeginInit();
            this.InitClass();
            base.EndInit();
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.InitVars(true);
        }

        [DebuggerNonUserCode]
        internal void InitVars(bool initTable)
        {
            this.tableBarcode = (BarcodeDataTable) base.Tables["Barcode"];
            if (initTable && (this.tableBarcode != null))
            {
                this.tableBarcode.InitVars();
            }
        }

        [DebuggerNonUserCode]
        protected override void ReadXmlSerializable(XmlReader reader)
        {
            if (base.DetermineSchemaSerializationMode(reader) == System.Data.SchemaSerializationMode.IncludeSchema)
            {
                this.Reset();
                DataSet dataSet = new DataSet();
                dataSet.ReadXml(reader);
                if (dataSet.Tables["Barcode"] != null)
                {
                    base.Tables.Add(new BarcodeDataTable(dataSet.Tables["Barcode"]));
                }
                base.DataSetName = dataSet.DataSetName;
                base.Prefix = dataSet.Prefix;
                base.Namespace = dataSet.Namespace;
                base.Locale = dataSet.Locale;
                base.CaseSensitive = dataSet.CaseSensitive;
                base.EnforceConstraints = dataSet.EnforceConstraints;
                base.Merge(dataSet, false, MissingSchemaAction.Add);
                this.InitVars();
            }
            else
            {
                base.ReadXml(reader);
                this.InitVars();
            }
        }

        [DebuggerNonUserCode]
        private void SchemaChanged(object sender, CollectionChangeEventArgs e)
        {
            if (e.Action == CollectionChangeAction.Remove)
            {
                this.InitVars();
            }
        }

        [DebuggerNonUserCode]
        private bool ShouldSerializeBarcode()
        {
            return false;
        }

        [DebuggerNonUserCode]
        protected override bool ShouldSerializeRelations()
        {
            return false;
        }

        [DebuggerNonUserCode]
        protected override bool ShouldSerializeTables()
        {
            return false;
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false), DebuggerNonUserCode]
        public BarcodeDataTable Barcode
        {
            get
            {
                return this.tableBarcode;
            }
        }

        [DebuggerNonUserCode, DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public DataRelationCollection Relations
        {
            get
            {
                return base.Relations;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible), Browsable(true), DebuggerNonUserCode]
        public override System.Data.SchemaSerializationMode SchemaSerializationMode
        {
            get
            {
                return this._schemaSerializationMode;
            }
            set
            {
                this._schemaSerializationMode = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), DebuggerNonUserCode]
        public DataTableCollection Tables
        {
            get
            {
                return base.Tables;
            }
        }

        [Serializable, GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedTableSchema")]
        public class BarcodeDataTable : DataTable, IEnumerable
        {
            private DataColumn columnBackcolor;
            private DataColumn columnCountryAssigningManufacturingCode;
            private DataColumn columnEncodedValue;
            private DataColumn columnEncodingTime;
            private DataColumn columnForecolor;
            private DataColumn columnImage;
            private DataColumn columnImageHeight;
            private DataColumn columnImageWidth;
            private DataColumn columnShowText;
            private DataColumn columnText;
            private DataColumn columnType;

            public event BarcodeXML.BarcodeRowChangeEventHandler BarcodeRowChanged;

            public event BarcodeXML.BarcodeRowChangeEventHandler BarcodeRowChanging;

            public event BarcodeXML.BarcodeRowChangeEventHandler BarcodeRowDeleted;

            public event BarcodeXML.BarcodeRowChangeEventHandler BarcodeRowDeleting;

            [DebuggerNonUserCode]
            public BarcodeDataTable()
            {
                base.TableName = "Barcode";
                this.BeginInit();
                this.InitClass();
                this.EndInit();
            }

            [DebuggerNonUserCode]
            internal BarcodeDataTable(DataTable table)
            {
                base.TableName = table.TableName;
                if (table.CaseSensitive != table.DataSet.CaseSensitive)
                {
                    base.CaseSensitive = table.CaseSensitive;
                }
                if (table.Locale.ToString() != table.DataSet.Locale.ToString())
                {
                    base.Locale = table.Locale;
                }
                if (table.Namespace != table.DataSet.Namespace)
                {
                    base.Namespace = table.Namespace;
                }
                base.Prefix = table.Prefix;
                base.MinimumCapacity = table.MinimumCapacity;
            }

            [DebuggerNonUserCode]
            protected BarcodeDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
            {
                this.InitVars();
            }

            [DebuggerNonUserCode]
            public void AddBarcodeRow(BarcodeXML.BarcodeRow row)
            {
                base.Rows.Add(row);
            }

            [DebuggerNonUserCode]
            public BarcodeXML.BarcodeRow AddBarcodeRow(string Type, string Text, string EncodedValue, double EncodingTime, bool ShowText, string Forecolor, string Backcolor, string CountryAssigningManufacturingCode, int ImageWidth, int ImageHeight, string Image)
            {
                BarcodeXML.BarcodeRow row = (BarcodeXML.BarcodeRow) base.NewRow();
                row.ItemArray = new object[] { Type, Text, EncodedValue, EncodingTime, ShowText, Forecolor, Backcolor, CountryAssigningManufacturingCode, ImageWidth, ImageHeight, Image };
                base.Rows.Add(row);
                return row;
            }

            [DebuggerNonUserCode]
            public override DataTable Clone()
            {
                BarcodeXML.BarcodeDataTable table = (BarcodeXML.BarcodeDataTable) base.Clone();
                table.InitVars();
                return table;
            }

            [DebuggerNonUserCode]
            protected override DataTable CreateInstance()
            {
                return new BarcodeXML.BarcodeDataTable();
            }

            [DebuggerNonUserCode]
            public virtual IEnumerator GetEnumerator()
            {
                return base.Rows.GetEnumerator();
            }

            [DebuggerNonUserCode]
            protected override Type GetRowType()
            {
                return typeof(BarcodeXML.BarcodeRow);
            }

            [DebuggerNonUserCode]
            public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
            {
                XmlSchemaComplexType type = new XmlSchemaComplexType();
                XmlSchemaSequence sequence = new XmlSchemaSequence();
                BarcodeXML exml = new BarcodeXML();
                XmlSchemaAny item = new XmlSchemaAny();
                item.Namespace = "http://www.w3.org/2001/XMLSchema";
                item.MinOccurs = 0M;
                item.MaxOccurs = 79228162514264337593543950335M;
                item.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(item);
                XmlSchemaAny any2 = new XmlSchemaAny();
                any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
                any2.MinOccurs = 1M;
                any2.ProcessContents = XmlSchemaContentProcessing.Lax;
                sequence.Items.Add(any2);
                XmlSchemaAttribute attribute = new XmlSchemaAttribute();
                attribute.Name = "namespace";
                attribute.FixedValue = exml.Namespace;
                type.Attributes.Add(attribute);
                XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
                attribute2.Name = "tableTypeName";
                attribute2.FixedValue = "BarcodeDataTable";
                type.Attributes.Add(attribute2);
                type.Particle = sequence;
                XmlSchema schemaSerializable = exml.GetSchemaSerializable();
                if (xs.Contains(schemaSerializable.TargetNamespace))
                {
                    MemoryStream stream = new MemoryStream();
                    MemoryStream stream2 = new MemoryStream();
                    try
                    {
                        XmlSchema current = null;
                        schemaSerializable.Write(stream);
                        IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            current = (XmlSchema) enumerator.Current;
                            stream2.SetLength(0L);
                            current.Write(stream2);
                            if (stream.Length == stream2.Length)
                            {
                                stream.Position = 0L;
                                stream2.Position = 0L;
                                while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                                {
                                }
                                if (stream.Position == stream.Length)
                                {
                                    return type;
                                }
                            }
                        }
                    }
                    finally
                    {
                        if (stream != null)
                        {
                            stream.Close();
                        }
                        if (stream2 != null)
                        {
                            stream2.Close();
                        }
                    }
                }
                xs.Add(schemaSerializable);
                return type;
            }

            [DebuggerNonUserCode]
            private void InitClass()
            {
                this.columnType = new DataColumn("Type", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnType);
                this.columnText = new DataColumn("Text", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnText);
                this.columnEncodedValue = new DataColumn("EncodedValue", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnEncodedValue);
                this.columnEncodingTime = new DataColumn("EncodingTime", typeof(double), null, MappingType.Element);
                base.Columns.Add(this.columnEncodingTime);
                this.columnShowText = new DataColumn("ShowText", typeof(bool), null, MappingType.Element);
                base.Columns.Add(this.columnShowText);
                this.columnForecolor = new DataColumn("Forecolor", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnForecolor);
                this.columnBackcolor = new DataColumn("Backcolor", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnBackcolor);
                this.columnCountryAssigningManufacturingCode = new DataColumn("CountryAssigningManufacturingCode", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnCountryAssigningManufacturingCode);
                this.columnImageWidth = new DataColumn("ImageWidth", typeof(int), null, MappingType.Element);
                base.Columns.Add(this.columnImageWidth);
                this.columnImageHeight = new DataColumn("ImageHeight", typeof(int), null, MappingType.Element);
                base.Columns.Add(this.columnImageHeight);
                this.columnImage = new DataColumn("Image", typeof(string), null, MappingType.Element);
                base.Columns.Add(this.columnImage);
                this.columnImage.MaxLength = 0x989680;
            }

            [DebuggerNonUserCode]
            internal void InitVars()
            {
                this.columnType = base.Columns["Type"];
                this.columnText = base.Columns["Text"];
                this.columnEncodedValue = base.Columns["EncodedValue"];
                this.columnEncodingTime = base.Columns["EncodingTime"];
                this.columnShowText = base.Columns["ShowText"];
                this.columnForecolor = base.Columns["Forecolor"];
                this.columnBackcolor = base.Columns["Backcolor"];
                this.columnCountryAssigningManufacturingCode = base.Columns["CountryAssigningManufacturingCode"];
                this.columnImageWidth = base.Columns["ImageWidth"];
                this.columnImageHeight = base.Columns["ImageHeight"];
                this.columnImage = base.Columns["Image"];
            }

            [DebuggerNonUserCode]
            public BarcodeXML.BarcodeRow NewBarcodeRow()
            {
                return (BarcodeXML.BarcodeRow) base.NewRow();
            }

            [DebuggerNonUserCode]
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
            {
                return new BarcodeXML.BarcodeRow(builder);
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanged(DataRowChangeEventArgs e)
            {
                base.OnRowChanged(e);
                if (this.BarcodeRowChanged != null)
                {
                    this.BarcodeRowChanged(this, new BarcodeXML.BarcodeRowChangeEvent((BarcodeXML.BarcodeRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowChanging(DataRowChangeEventArgs e)
            {
                base.OnRowChanging(e);
                if (this.BarcodeRowChanging != null)
                {
                    this.BarcodeRowChanging(this, new BarcodeXML.BarcodeRowChangeEvent((BarcodeXML.BarcodeRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleted(DataRowChangeEventArgs e)
            {
                base.OnRowDeleted(e);
                if (this.BarcodeRowDeleted != null)
                {
                    this.BarcodeRowDeleted(this, new BarcodeXML.BarcodeRowChangeEvent((BarcodeXML.BarcodeRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            protected override void OnRowDeleting(DataRowChangeEventArgs e)
            {
                base.OnRowDeleting(e);
                if (this.BarcodeRowDeleting != null)
                {
                    this.BarcodeRowDeleting(this, new BarcodeXML.BarcodeRowChangeEvent((BarcodeXML.BarcodeRow) e.Row, e.Action));
                }
            }

            [DebuggerNonUserCode]
            public void RemoveBarcodeRow(BarcodeXML.BarcodeRow row)
            {
                base.Rows.Remove(row);
            }

            [DebuggerNonUserCode]
            public DataColumn BackcolorColumn
            {
                get
                {
                    return this.columnBackcolor;
                }
            }

            [DebuggerNonUserCode, Browsable(false)]
            public int Count
            {
                get
                {
                    return base.Rows.Count;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn CountryAssigningManufacturingCodeColumn
            {
                get
                {
                    return this.columnCountryAssigningManufacturingCode;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn EncodedValueColumn
            {
                get
                {
                    return this.columnEncodedValue;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn EncodingTimeColumn
            {
                get
                {
                    return this.columnEncodingTime;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn ForecolorColumn
            {
                get
                {
                    return this.columnForecolor;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn ImageColumn
            {
                get
                {
                    return this.columnImage;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn ImageHeightColumn
            {
                get
                {
                    return this.columnImageHeight;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn ImageWidthColumn
            {
                get
                {
                    return this.columnImageWidth;
                }
            }

            [DebuggerNonUserCode]
            public BarcodeXML.BarcodeRow this[int index]
            {
                get
                {
                    return (BarcodeXML.BarcodeRow) base.Rows[index];
                }
            }

            [DebuggerNonUserCode]
            public DataColumn ShowTextColumn
            {
                get
                {
                    return this.columnShowText;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn TextColumn
            {
                get
                {
                    return this.columnText;
                }
            }

            [DebuggerNonUserCode]
            public DataColumn TypeColumn
            {
                get
                {
                    return this.columnType;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class BarcodeRow : DataRow
        {
            private BarcodeXML.BarcodeDataTable tableBarcode;

            [DebuggerNonUserCode]
            internal BarcodeRow(DataRowBuilder rb) : base(rb)
            {
                this.tableBarcode = (BarcodeXML.BarcodeDataTable) base.Table;
            }

            [DebuggerNonUserCode]
            public bool IsBackcolorNull()
            {
                return base.IsNull(this.tableBarcode.BackcolorColumn);
            }

            [DebuggerNonUserCode]
            public bool IsCountryAssigningManufacturingCodeNull()
            {
                return base.IsNull(this.tableBarcode.CountryAssigningManufacturingCodeColumn);
            }

            [DebuggerNonUserCode]
            public bool IsEncodedValueNull()
            {
                return base.IsNull(this.tableBarcode.EncodedValueColumn);
            }

            [DebuggerNonUserCode]
            public bool IsEncodingTimeNull()
            {
                return base.IsNull(this.tableBarcode.EncodingTimeColumn);
            }

            [DebuggerNonUserCode]
            public bool IsForecolorNull()
            {
                return base.IsNull(this.tableBarcode.ForecolorColumn);
            }

            [DebuggerNonUserCode]
            public bool IsImageHeightNull()
            {
                return base.IsNull(this.tableBarcode.ImageHeightColumn);
            }

            [DebuggerNonUserCode]
            public bool IsImageNull()
            {
                return base.IsNull(this.tableBarcode.ImageColumn);
            }

            [DebuggerNonUserCode]
            public bool IsImageWidthNull()
            {
                return base.IsNull(this.tableBarcode.ImageWidthColumn);
            }

            [DebuggerNonUserCode]
            public bool IsShowTextNull()
            {
                return base.IsNull(this.tableBarcode.ShowTextColumn);
            }

            [DebuggerNonUserCode]
            public bool IsTextNull()
            {
                return base.IsNull(this.tableBarcode.TextColumn);
            }

            [DebuggerNonUserCode]
            public bool IsTypeNull()
            {
                return base.IsNull(this.tableBarcode.TypeColumn);
            }

            [DebuggerNonUserCode]
            public void SetBackcolorNull()
            {
                base[this.tableBarcode.BackcolorColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetCountryAssigningManufacturingCodeNull()
            {
                base[this.tableBarcode.CountryAssigningManufacturingCodeColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetEncodedValueNull()
            {
                base[this.tableBarcode.EncodedValueColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetEncodingTimeNull()
            {
                base[this.tableBarcode.EncodingTimeColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetForecolorNull()
            {
                base[this.tableBarcode.ForecolorColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetImageHeightNull()
            {
                base[this.tableBarcode.ImageHeightColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetImageNull()
            {
                base[this.tableBarcode.ImageColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetImageWidthNull()
            {
                base[this.tableBarcode.ImageWidthColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetShowTextNull()
            {
                base[this.tableBarcode.ShowTextColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetTextNull()
            {
                base[this.tableBarcode.TextColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public void SetTypeNull()
            {
                base[this.tableBarcode.TypeColumn] = Convert.DBNull;
            }

            [DebuggerNonUserCode]
            public string Backcolor
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.BackcolorColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Backcolor' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.BackcolorColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string CountryAssigningManufacturingCode
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.CountryAssigningManufacturingCodeColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'CountryAssigningManufacturingCode' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.CountryAssigningManufacturingCodeColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string EncodedValue
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.EncodedValueColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'EncodedValue' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.EncodedValueColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public double EncodingTime
            {
                get
                {
                    double num;
                    try
                    {
                        num = (double) base[this.tableBarcode.EncodingTimeColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'EncodingTime' in table 'Barcode' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableBarcode.EncodingTimeColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Forecolor
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.ForecolorColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Forecolor' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.ForecolorColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Image
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.ImageColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Image' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.ImageColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public int ImageHeight
            {
                get
                {
                    int num;
                    try
                    {
                        num = (int) base[this.tableBarcode.ImageHeightColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'ImageHeight' in table 'Barcode' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableBarcode.ImageHeightColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public int ImageWidth
            {
                get
                {
                    int num;
                    try
                    {
                        num = (int) base[this.tableBarcode.ImageWidthColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'ImageWidth' in table 'Barcode' is DBNull.", exception);
                    }
                    return num;
                }
                set
                {
                    base[this.tableBarcode.ImageWidthColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public bool ShowText
            {
                get
                {
                    bool flag;
                    try
                    {
                        flag = (bool) base[this.tableBarcode.ShowTextColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'ShowText' in table 'Barcode' is DBNull.", exception);
                    }
                    return flag;
                }
                set
                {
                    base[this.tableBarcode.ShowTextColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Text
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.TextColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Text' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.TextColumn] = value;
                }
            }

            [DebuggerNonUserCode]
            public string Type
            {
                get
                {
                    string str;
                    try
                    {
                        str = (string) base[this.tableBarcode.TypeColumn];
                    }
                    catch (InvalidCastException exception)
                    {
                        throw new StrongTypingException("The value for column 'Type' in table 'Barcode' is DBNull.", exception);
                    }
                    return str;
                }
                set
                {
                    base[this.tableBarcode.TypeColumn] = value;
                }
            }
        }

        [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
        public class BarcodeRowChangeEvent : EventArgs
        {
            private DataRowAction eventAction;
            private BarcodeXML.BarcodeRow eventRow;

            [DebuggerNonUserCode]
            public BarcodeRowChangeEvent(BarcodeXML.BarcodeRow row, DataRowAction action)
            {
                this.eventRow = row;
                this.eventAction = action;
            }

            [DebuggerNonUserCode]
            public DataRowAction Action
            {
                get
                {
                    return this.eventAction;
                }
            }

            [DebuggerNonUserCode]
            public BarcodeXML.BarcodeRow Row
            {
                get
                {
                    return this.eventRow;
                }
            }
        }

        public delegate void BarcodeRowChangeEventHandler(object sender, BarcodeXML.BarcodeRowChangeEvent e);
    }
}

